/**
 * Copyright (c) 2015-2017, Henry Yang 杨勇 (gismail@foxmail.com).
 * <p>
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * <p>
 * http://www.apache.org/licenses/LICENSE-2.0
 * <p>
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.mapfinal.server.auth.model;

import com.lambkit.db.sql.ConditionMode;
import com.lambkit.db.sql.column.Column;
import com.lambkit.db.sql.column.Columns;
import com.lambkit.db.sql.column.Example;

import java.io.Serializable;
import java.util.List;

/**
 * @author yangyong 
 * @website: www.lambkit.com
 * @email: gismail@foxmail.com
 * @date 2020-09-23
 * @version 1.0
 * @since 1.0
 */
public class AuthRuleCriteria extends Columns implements Serializable {
	private static final long serialVersionUID = 1L;
	
	public static AuthRuleCriteria create() {
		return new AuthRuleCriteria();
	}
	
	public static AuthRuleCriteria create(Column column) {
		AuthRuleCriteria that = new AuthRuleCriteria();
		that.add(column);
        return that;
    }

    public static AuthRuleCriteria create(String name, Object value) {
        return (AuthRuleCriteria) create().eq(name, value);
    }
    
    public Example example() {
    	return Example.create("lk_auth_rule", this);
    }
    
    /**
     * equals
     *
     * @param name
     * @param value
     * @return
     */
    public AuthRuleCriteria eq(String name, Object value) {
    	super.eq(name, value);
        return this;
    }

    /**
     * not equals !=
     *
     * @param name
     * @param value
     * @return
     */
    public AuthRuleCriteria ne(String name, Object value) {
    	super.ne(name, value);
        return this;
    }


    /**
     * like
     *
     * @param name
     * @param value
     * @return
     */

    public AuthRuleCriteria like(String name, Object value) {
    	super.like(name, value);
        return this;
    }
    
    public AuthRuleCriteria notLike(String name, Object value) {
    	super.notLike(name, value);
        return this;
    }

    /**
     * 大于 great than
     *
     * @param name
     * @param value
     * @return
     */
    public AuthRuleCriteria gt(String name, Object value) {
    	super.gt(name, value);
        return this;
    }

    /**
     * 大于等于 great or equal
     *
     * @param name
     * @param value
     * @return
     */
    public AuthRuleCriteria ge(String name, Object value) {
    	super.ge(name, value);
        return this;
    }

    /**
     * 小于 less than
     *
     * @param name
     * @param value
     * @return
     */
    public AuthRuleCriteria lt(String name, Object value) {
    	super.lt(name, value);
        return this;
    }

    /**
     * 小于等于 less or equal
     *
     * @param name
     * @param value
     * @return
     */
    public AuthRuleCriteria le(String name, Object value) {
    	super.le(name, value);
        return this;
    }
    
    public AuthRuleCriteria isnull(String name) {
    	super.isnull(name);
        return this;
    } 

    public AuthRuleCriteria notNull(String name) {
    	super.notNull(name);
        return this;
    } 
    
    public AuthRuleCriteria empty(String name) {
    	super.empty(name);
        return this;
    } 
    
    public AuthRuleCriteria notEmpty(String name) {
    	super.notEmpty(name);
        return this;
    } 
    
    public AuthRuleCriteria add(Column column) {
    	super.add(column);
    	return this;
    }
    
    /**************************/
	
	public void addCriterion(String name, Object value, ConditionMode logic, String property, String typeHandler, String valueType) {
		 if (value == null) {
			 throw new RuntimeException("Value for " + property + " cannot be null");
		 }
		 add(Column.create(name, value, logic, typeHandler, valueType));
	}
   
	public void addCriterion(String name, Object value1, Object value2, ConditionMode logic, String property, String typeHandler, String valueType) {
		 if (value1 == null || value2 == null) {
			 throw new RuntimeException("Between values for " + property + " cannot be null");
		 }
		 add(Column.create(name, value1, value2, logic, typeHandler, valueType));
	}
		 
	public AuthRuleCriteria andIdIsNull() {
		isnull("id");
		return this;
	}
	
	public AuthRuleCriteria andIdIsNotNull() {
		notNull("id");
		return this;
	}
	
	public AuthRuleCriteria andIdIsEmpty() {
		empty("id");
		return this;
	}

	public AuthRuleCriteria andIdIsNotEmpty() {
		notEmpty("id");
		return this;
	}
       public AuthRuleCriteria andIdEqualTo(java.lang.Integer value) {
          addCriterion("id", value, ConditionMode.EQUAL, "id", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andIdNotEqualTo(java.lang.Integer value) {
          addCriterion("id", value, ConditionMode.NOT_EQUAL, "id", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andIdGreaterThan(java.lang.Integer value) {
          addCriterion("id", value, ConditionMode.GREATER_THEN, "id", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andIdGreaterThanOrEqualTo(java.lang.Integer value) {
          addCriterion("id", value, ConditionMode.GREATER_EQUAL, "id", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andIdLessThan(java.lang.Integer value) {
          addCriterion("id", value, ConditionMode.LESS_THEN, "id", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andIdLessThanOrEqualTo(java.lang.Integer value) {
          addCriterion("id", value, ConditionMode.LESS_EQUAL, "id", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andIdBetween(java.lang.Integer value1, java.lang.Integer value2) {
    	  addCriterion("id", value1, value2, ConditionMode.BETWEEN, "id", "java.lang.Integer", "Float");
    	  return this;
      }

      public AuthRuleCriteria andIdNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
          addCriterion("id", value1, value2, ConditionMode.NOT_BETWEEN, "id", "java.lang.Integer", "Float");
          return this;
      }
        
      public AuthRuleCriteria andIdIn(List<java.lang.Integer> values) {
          addCriterion("id", values, ConditionMode.IN, "id", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andIdNotIn(List<java.lang.Integer> values) {
          addCriterion("id", values, ConditionMode.NOT_IN, "id", "java.lang.Integer", "Float");
          return this;
      }
	public AuthRuleCriteria andModuleIsNull() {
		isnull("module");
		return this;
	}
	
	public AuthRuleCriteria andModuleIsNotNull() {
		notNull("module");
		return this;
	}
	
	public AuthRuleCriteria andModuleIsEmpty() {
		empty("module");
		return this;
	}

	public AuthRuleCriteria andModuleIsNotEmpty() {
		notEmpty("module");
		return this;
	}
        public AuthRuleCriteria andModuleLike(java.lang.String value) {
    	   addCriterion("module", value, ConditionMode.FUZZY, "module", "java.lang.String", "Float");
    	   return this;
      }

      public AuthRuleCriteria andModuleNotLike(java.lang.String value) {
          addCriterion("module", value, ConditionMode.NOT_FUZZY, "module", "java.lang.String", "Float");
          return this;
      }
      public AuthRuleCriteria andModuleEqualTo(java.lang.String value) {
          addCriterion("module", value, ConditionMode.EQUAL, "module", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andModuleNotEqualTo(java.lang.String value) {
          addCriterion("module", value, ConditionMode.NOT_EQUAL, "module", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andModuleGreaterThan(java.lang.String value) {
          addCriterion("module", value, ConditionMode.GREATER_THEN, "module", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andModuleGreaterThanOrEqualTo(java.lang.String value) {
          addCriterion("module", value, ConditionMode.GREATER_EQUAL, "module", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andModuleLessThan(java.lang.String value) {
          addCriterion("module", value, ConditionMode.LESS_THEN, "module", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andModuleLessThanOrEqualTo(java.lang.String value) {
          addCriterion("module", value, ConditionMode.LESS_EQUAL, "module", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andModuleBetween(java.lang.String value1, java.lang.String value2) {
    	  addCriterion("module", value1, value2, ConditionMode.BETWEEN, "module", "java.lang.String", "String");
    	  return this;
      }

      public AuthRuleCriteria andModuleNotBetween(java.lang.String value1, java.lang.String value2) {
          addCriterion("module", value1, value2, ConditionMode.NOT_BETWEEN, "module", "java.lang.String", "String");
          return this;
      }
        
      public AuthRuleCriteria andModuleIn(List<java.lang.String> values) {
          addCriterion("module", values, ConditionMode.IN, "module", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andModuleNotIn(List<java.lang.String> values) {
          addCriterion("module", values, ConditionMode.NOT_IN, "module", "java.lang.String", "String");
          return this;
      }
	public AuthRuleCriteria andTypeIsNull() {
		isnull("type");
		return this;
	}
	
	public AuthRuleCriteria andTypeIsNotNull() {
		notNull("type");
		return this;
	}
	
	public AuthRuleCriteria andTypeIsEmpty() {
		empty("type");
		return this;
	}

	public AuthRuleCriteria andTypeIsNotEmpty() {
		notEmpty("type");
		return this;
	}
        public AuthRuleCriteria andTypeLike(java.lang.String value) {
    	   addCriterion("type", value, ConditionMode.FUZZY, "type", "java.lang.String", "String");
    	   return this;
      }

      public AuthRuleCriteria andTypeNotLike(java.lang.String value) {
          addCriterion("type", value, ConditionMode.NOT_FUZZY, "type", "java.lang.String", "String");
          return this;
      }
      public AuthRuleCriteria andTypeEqualTo(java.lang.String value) {
          addCriterion("type", value, ConditionMode.EQUAL, "type", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTypeNotEqualTo(java.lang.String value) {
          addCriterion("type", value, ConditionMode.NOT_EQUAL, "type", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTypeGreaterThan(java.lang.String value) {
          addCriterion("type", value, ConditionMode.GREATER_THEN, "type", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTypeGreaterThanOrEqualTo(java.lang.String value) {
          addCriterion("type", value, ConditionMode.GREATER_EQUAL, "type", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTypeLessThan(java.lang.String value) {
          addCriterion("type", value, ConditionMode.LESS_THEN, "type", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTypeLessThanOrEqualTo(java.lang.String value) {
          addCriterion("type", value, ConditionMode.LESS_EQUAL, "type", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTypeBetween(java.lang.String value1, java.lang.String value2) {
    	  addCriterion("type", value1, value2, ConditionMode.BETWEEN, "type", "java.lang.String", "String");
    	  return this;
      }

      public AuthRuleCriteria andTypeNotBetween(java.lang.String value1, java.lang.String value2) {
          addCriterion("type", value1, value2, ConditionMode.NOT_BETWEEN, "type", "java.lang.String", "String");
          return this;
      }
        
      public AuthRuleCriteria andTypeIn(List<java.lang.String> values) {
          addCriterion("type", values, ConditionMode.IN, "type", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTypeNotIn(List<java.lang.String> values) {
          addCriterion("type", values, ConditionMode.NOT_IN, "type", "java.lang.String", "String");
          return this;
      }
	public AuthRuleCriteria andNameIsNull() {
		isnull("name");
		return this;
	}
	
	public AuthRuleCriteria andNameIsNotNull() {
		notNull("name");
		return this;
	}
	
	public AuthRuleCriteria andNameIsEmpty() {
		empty("name");
		return this;
	}

	public AuthRuleCriteria andNameIsNotEmpty() {
		notEmpty("name");
		return this;
	}
        public AuthRuleCriteria andNameLike(java.lang.String value) {
    	   addCriterion("name", value, ConditionMode.FUZZY, "name", "java.lang.String", "String");
    	   return this;
      }

      public AuthRuleCriteria andNameNotLike(java.lang.String value) {
          addCriterion("name", value, ConditionMode.NOT_FUZZY, "name", "java.lang.String", "String");
          return this;
      }
      public AuthRuleCriteria andNameEqualTo(java.lang.String value) {
          addCriterion("name", value, ConditionMode.EQUAL, "name", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andNameNotEqualTo(java.lang.String value) {
          addCriterion("name", value, ConditionMode.NOT_EQUAL, "name", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andNameGreaterThan(java.lang.String value) {
          addCriterion("name", value, ConditionMode.GREATER_THEN, "name", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andNameGreaterThanOrEqualTo(java.lang.String value) {
          addCriterion("name", value, ConditionMode.GREATER_EQUAL, "name", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andNameLessThan(java.lang.String value) {
          addCriterion("name", value, ConditionMode.LESS_THEN, "name", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andNameLessThanOrEqualTo(java.lang.String value) {
          addCriterion("name", value, ConditionMode.LESS_EQUAL, "name", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andNameBetween(java.lang.String value1, java.lang.String value2) {
    	  addCriterion("name", value1, value2, ConditionMode.BETWEEN, "name", "java.lang.String", "String");
    	  return this;
      }

      public AuthRuleCriteria andNameNotBetween(java.lang.String value1, java.lang.String value2) {
          addCriterion("name", value1, value2, ConditionMode.NOT_BETWEEN, "name", "java.lang.String", "String");
          return this;
      }
        
      public AuthRuleCriteria andNameIn(List<java.lang.String> values) {
          addCriterion("name", values, ConditionMode.IN, "name", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andNameNotIn(List<java.lang.String> values) {
          addCriterion("name", values, ConditionMode.NOT_IN, "name", "java.lang.String", "String");
          return this;
      }
	public AuthRuleCriteria andParamIsNull() {
		isnull("param");
		return this;
	}
	
	public AuthRuleCriteria andParamIsNotNull() {
		notNull("param");
		return this;
	}
	
	public AuthRuleCriteria andParamIsEmpty() {
		empty("param");
		return this;
	}

	public AuthRuleCriteria andParamIsNotEmpty() {
		notEmpty("param");
		return this;
	}
        public AuthRuleCriteria andParamLike(java.lang.String value) {
    	   addCriterion("param", value, ConditionMode.FUZZY, "param", "java.lang.String", "String");
    	   return this;
      }

      public AuthRuleCriteria andParamNotLike(java.lang.String value) {
          addCriterion("param", value, ConditionMode.NOT_FUZZY, "param", "java.lang.String", "String");
          return this;
      }
      public AuthRuleCriteria andParamEqualTo(java.lang.String value) {
          addCriterion("param", value, ConditionMode.EQUAL, "param", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andParamNotEqualTo(java.lang.String value) {
          addCriterion("param", value, ConditionMode.NOT_EQUAL, "param", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andParamGreaterThan(java.lang.String value) {
          addCriterion("param", value, ConditionMode.GREATER_THEN, "param", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andParamGreaterThanOrEqualTo(java.lang.String value) {
          addCriterion("param", value, ConditionMode.GREATER_EQUAL, "param", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andParamLessThan(java.lang.String value) {
          addCriterion("param", value, ConditionMode.LESS_THEN, "param", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andParamLessThanOrEqualTo(java.lang.String value) {
          addCriterion("param", value, ConditionMode.LESS_EQUAL, "param", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andParamBetween(java.lang.String value1, java.lang.String value2) {
    	  addCriterion("param", value1, value2, ConditionMode.BETWEEN, "param", "java.lang.String", "String");
    	  return this;
      }

      public AuthRuleCriteria andParamNotBetween(java.lang.String value1, java.lang.String value2) {
          addCriterion("param", value1, value2, ConditionMode.NOT_BETWEEN, "param", "java.lang.String", "String");
          return this;
      }
        
      public AuthRuleCriteria andParamIn(List<java.lang.String> values) {
          addCriterion("param", values, ConditionMode.IN, "param", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andParamNotIn(List<java.lang.String> values) {
          addCriterion("param", values, ConditionMode.NOT_IN, "param", "java.lang.String", "String");
          return this;
      }
	public AuthRuleCriteria andTitleIsNull() {
		isnull("title");
		return this;
	}
	
	public AuthRuleCriteria andTitleIsNotNull() {
		notNull("title");
		return this;
	}
	
	public AuthRuleCriteria andTitleIsEmpty() {
		empty("title");
		return this;
	}

	public AuthRuleCriteria andTitleIsNotEmpty() {
		notEmpty("title");
		return this;
	}
        public AuthRuleCriteria andTitleLike(java.lang.String value) {
    	   addCriterion("title", value, ConditionMode.FUZZY, "title", "java.lang.String", "String");
    	   return this;
      }

      public AuthRuleCriteria andTitleNotLike(java.lang.String value) {
          addCriterion("title", value, ConditionMode.NOT_FUZZY, "title", "java.lang.String", "String");
          return this;
      }
      public AuthRuleCriteria andTitleEqualTo(java.lang.String value) {
          addCriterion("title", value, ConditionMode.EQUAL, "title", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTitleNotEqualTo(java.lang.String value) {
          addCriterion("title", value, ConditionMode.NOT_EQUAL, "title", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTitleGreaterThan(java.lang.String value) {
          addCriterion("title", value, ConditionMode.GREATER_THEN, "title", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTitleGreaterThanOrEqualTo(java.lang.String value) {
          addCriterion("title", value, ConditionMode.GREATER_EQUAL, "title", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTitleLessThan(java.lang.String value) {
          addCriterion("title", value, ConditionMode.LESS_THEN, "title", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTitleLessThanOrEqualTo(java.lang.String value) {
          addCriterion("title", value, ConditionMode.LESS_EQUAL, "title", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTitleBetween(java.lang.String value1, java.lang.String value2) {
    	  addCriterion("title", value1, value2, ConditionMode.BETWEEN, "title", "java.lang.String", "String");
    	  return this;
      }

      public AuthRuleCriteria andTitleNotBetween(java.lang.String value1, java.lang.String value2) {
          addCriterion("title", value1, value2, ConditionMode.NOT_BETWEEN, "title", "java.lang.String", "String");
          return this;
      }
        
      public AuthRuleCriteria andTitleIn(List<java.lang.String> values) {
          addCriterion("title", values, ConditionMode.IN, "title", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andTitleNotIn(List<java.lang.String> values) {
          addCriterion("title", values, ConditionMode.NOT_IN, "title", "java.lang.String", "String");
          return this;
      }
	public AuthRuleCriteria andStatusIsNull() {
		isnull("status");
		return this;
	}
	
	public AuthRuleCriteria andStatusIsNotNull() {
		notNull("status");
		return this;
	}
	
	public AuthRuleCriteria andStatusIsEmpty() {
		empty("status");
		return this;
	}

	public AuthRuleCriteria andStatusIsNotEmpty() {
		notEmpty("status");
		return this;
	}
       public AuthRuleCriteria andStatusEqualTo(java.lang.Integer value) {
          addCriterion("status", value, ConditionMode.EQUAL, "status", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andStatusNotEqualTo(java.lang.Integer value) {
          addCriterion("status", value, ConditionMode.NOT_EQUAL, "status", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andStatusGreaterThan(java.lang.Integer value) {
          addCriterion("status", value, ConditionMode.GREATER_THEN, "status", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andStatusGreaterThanOrEqualTo(java.lang.Integer value) {
          addCriterion("status", value, ConditionMode.GREATER_EQUAL, "status", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andStatusLessThan(java.lang.Integer value) {
          addCriterion("status", value, ConditionMode.LESS_THEN, "status", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andStatusLessThanOrEqualTo(java.lang.Integer value) {
          addCriterion("status", value, ConditionMode.LESS_EQUAL, "status", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andStatusBetween(java.lang.Integer value1, java.lang.Integer value2) {
    	  addCriterion("status", value1, value2, ConditionMode.BETWEEN, "status", "java.lang.Integer", "Float");
    	  return this;
      }

      public AuthRuleCriteria andStatusNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
          addCriterion("status", value1, value2, ConditionMode.NOT_BETWEEN, "status", "java.lang.Integer", "Float");
          return this;
      }
        
      public AuthRuleCriteria andStatusIn(List<java.lang.Integer> values) {
          addCriterion("status", values, ConditionMode.IN, "status", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andStatusNotIn(List<java.lang.Integer> values) {
          addCriterion("status", values, ConditionMode.NOT_IN, "status", "java.lang.Integer", "Float");
          return this;
      }
	public AuthRuleCriteria andConditionIsNull() {
		isnull("condition");
		return this;
	}
	
	public AuthRuleCriteria andConditionIsNotNull() {
		notNull("condition");
		return this;
	}
	
	public AuthRuleCriteria andConditionIsEmpty() {
		empty("condition");
		return this;
	}

	public AuthRuleCriteria andConditionIsNotEmpty() {
		notEmpty("condition");
		return this;
	}
        public AuthRuleCriteria andConditionLike(java.lang.String value) {
    	   addCriterion("condition", value, ConditionMode.FUZZY, "condition", "java.lang.String", "Float");
    	   return this;
      }

      public AuthRuleCriteria andConditionNotLike(java.lang.String value) {
          addCriterion("condition", value, ConditionMode.NOT_FUZZY, "condition", "java.lang.String", "Float");
          return this;
      }
      public AuthRuleCriteria andConditionEqualTo(java.lang.String value) {
          addCriterion("condition", value, ConditionMode.EQUAL, "condition", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andConditionNotEqualTo(java.lang.String value) {
          addCriterion("condition", value, ConditionMode.NOT_EQUAL, "condition", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andConditionGreaterThan(java.lang.String value) {
          addCriterion("condition", value, ConditionMode.GREATER_THEN, "condition", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andConditionGreaterThanOrEqualTo(java.lang.String value) {
          addCriterion("condition", value, ConditionMode.GREATER_EQUAL, "condition", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andConditionLessThan(java.lang.String value) {
          addCriterion("condition", value, ConditionMode.LESS_THEN, "condition", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andConditionLessThanOrEqualTo(java.lang.String value) {
          addCriterion("condition", value, ConditionMode.LESS_EQUAL, "condition", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andConditionBetween(java.lang.String value1, java.lang.String value2) {
    	  addCriterion("condition", value1, value2, ConditionMode.BETWEEN, "condition", "java.lang.String", "String");
    	  return this;
      }

      public AuthRuleCriteria andConditionNotBetween(java.lang.String value1, java.lang.String value2) {
          addCriterion("condition", value1, value2, ConditionMode.NOT_BETWEEN, "condition", "java.lang.String", "String");
          return this;
      }
        
      public AuthRuleCriteria andConditionIn(List<java.lang.String> values) {
          addCriterion("condition", values, ConditionMode.IN, "condition", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andConditionNotIn(List<java.lang.String> values) {
          addCriterion("condition", values, ConditionMode.NOT_IN, "condition", "java.lang.String", "String");
          return this;
      }
	public AuthRuleCriteria andValueIsNull() {
		isnull("value");
		return this;
	}
	
	public AuthRuleCriteria andValueIsNotNull() {
		notNull("value");
		return this;
	}
	
	public AuthRuleCriteria andValueIsEmpty() {
		empty("value");
		return this;
	}

	public AuthRuleCriteria andValueIsNotEmpty() {
		notEmpty("value");
		return this;
	}
        public AuthRuleCriteria andValueLike(java.lang.String value) {
    	   addCriterion("value", value, ConditionMode.FUZZY, "value", "java.lang.String", "String");
    	   return this;
      }

      public AuthRuleCriteria andValueNotLike(java.lang.String value) {
          addCriterion("value", value, ConditionMode.NOT_FUZZY, "value", "java.lang.String", "String");
          return this;
      }
      public AuthRuleCriteria andValueEqualTo(java.lang.String value) {
          addCriterion("value", value, ConditionMode.EQUAL, "value", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andValueNotEqualTo(java.lang.String value) {
          addCriterion("value", value, ConditionMode.NOT_EQUAL, "value", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andValueGreaterThan(java.lang.String value) {
          addCriterion("value", value, ConditionMode.GREATER_THEN, "value", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andValueGreaterThanOrEqualTo(java.lang.String value) {
          addCriterion("value", value, ConditionMode.GREATER_EQUAL, "value", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andValueLessThan(java.lang.String value) {
          addCriterion("value", value, ConditionMode.LESS_THEN, "value", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andValueLessThanOrEqualTo(java.lang.String value) {
          addCriterion("value", value, ConditionMode.LESS_EQUAL, "value", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andValueBetween(java.lang.String value1, java.lang.String value2) {
    	  addCriterion("value", value1, value2, ConditionMode.BETWEEN, "value", "java.lang.String", "String");
    	  return this;
      }

      public AuthRuleCriteria andValueNotBetween(java.lang.String value1, java.lang.String value2) {
          addCriterion("value", value1, value2, ConditionMode.NOT_BETWEEN, "value", "java.lang.String", "String");
          return this;
      }
        
      public AuthRuleCriteria andValueIn(List<java.lang.String> values) {
          addCriterion("value", values, ConditionMode.IN, "value", "java.lang.String", "String");
          return this;
      }

      public AuthRuleCriteria andValueNotIn(List<java.lang.String> values) {
          addCriterion("value", values, ConditionMode.NOT_IN, "value", "java.lang.String", "String");
          return this;
      }
	public AuthRuleCriteria andPidIsNull() {
		isnull("pid");
		return this;
	}
	
	public AuthRuleCriteria andPidIsNotNull() {
		notNull("pid");
		return this;
	}
	
	public AuthRuleCriteria andPidIsEmpty() {
		empty("pid");
		return this;
	}

	public AuthRuleCriteria andPidIsNotEmpty() {
		notEmpty("pid");
		return this;
	}
       public AuthRuleCriteria andPidEqualTo(java.lang.Integer value) {
          addCriterion("pid", value, ConditionMode.EQUAL, "pid", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andPidNotEqualTo(java.lang.Integer value) {
          addCriterion("pid", value, ConditionMode.NOT_EQUAL, "pid", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andPidGreaterThan(java.lang.Integer value) {
          addCriterion("pid", value, ConditionMode.GREATER_THEN, "pid", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andPidGreaterThanOrEqualTo(java.lang.Integer value) {
          addCriterion("pid", value, ConditionMode.GREATER_EQUAL, "pid", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andPidLessThan(java.lang.Integer value) {
          addCriterion("pid", value, ConditionMode.LESS_THEN, "pid", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andPidLessThanOrEqualTo(java.lang.Integer value) {
          addCriterion("pid", value, ConditionMode.LESS_EQUAL, "pid", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andPidBetween(java.lang.Integer value1, java.lang.Integer value2) {
    	  addCriterion("pid", value1, value2, ConditionMode.BETWEEN, "pid", "java.lang.Integer", "Float");
    	  return this;
      }

      public AuthRuleCriteria andPidNotBetween(java.lang.Integer value1, java.lang.Integer value2) {
          addCriterion("pid", value1, value2, ConditionMode.NOT_BETWEEN, "pid", "java.lang.Integer", "Float");
          return this;
      }
        
      public AuthRuleCriteria andPidIn(List<java.lang.Integer> values) {
          addCriterion("pid", values, ConditionMode.IN, "pid", "java.lang.Integer", "Float");
          return this;
      }

      public AuthRuleCriteria andPidNotIn(List<java.lang.Integer> values) {
          addCriterion("pid", values, ConditionMode.NOT_IN, "pid", "java.lang.Integer", "Float");
          return this;
      }
}